home *** CD-ROM | disk | FTP | other *** search
/ PC World Interactive 7 / PC World Interactive 7.iso / program / ctutor.exe / SOURCE / VIDEO.C < prev    next >
Encoding:
C/C++ Source or Header  |  1994-05-15  |  13.1 KB  |  421 lines
  1. /* Video Output Routines                                           */
  2. /* Copyright (c) 1994 Coronado Enterprises                         */
  3.  
  4. #include <stdio.h> 
  5. #include <dos.h>
  6. #include <string.h>
  7. #include "vc.h"
  8. #include "video.h"
  9.  
  10. char strngout[80];
  11. static char outlist[160];
  12. static int bkattr;              /* background attribute (boxes)    */
  13. static int valattr;             /* values and variables attribute  */
  14. static int trnsattr;            /* transcript attribute            */
  15. static int helpattr;            /* help attribute                  */
  16. static int errattr;             /* error message attribute         */
  17. static int vidstart;            /* start of video memory           */
  18.  
  19.  
  20.  
  21. /********************************************************* monitor */
  22. /* This function looks at location 0449(hex) in memory to          */
  23. /*  determine what type of monitor is being used and adjusts the   */
  24. /*  video attributes accordingly. This allows for flexibility.     */
  25. void monitor(void)
  26. {
  27. char i[2];
  28. struct SREGS segregs;
  29. unsigned int ds;
  30.  
  31.    segread(&segregs);
  32.    ds = segregs.ds;
  33.                         /* get monitor mode from address 0000:0449 */
  34.    movedata(0, 0x449, ds, (int)i, 1);
  35.    if (i[0] == 7) {               /* monochrome monitor in use     */
  36.       bkattr = 7;
  37.       valattr = 7;
  38.       trnsattr = 7;
  39.       helpattr = 7;
  40.       errattr = 7;
  41.       vidstart = 0XB000;
  42.    } else {                       /* color monitor in use          */
  43.       bkattr = 15;                /* bright white                  */
  44.       valattr = 10;               /* light green                   */
  45.       trnsattr = 14;              /* yellow                        */
  46.       helpattr = 10;              /* light green                   */
  47.       errattr = 128 + 12;         /* blinking light red            */
  48.       vidstart = 0XB800;
  49.    }
  50. }
  51.  
  52.  
  53.  
  54. /******************************************************** bkgndvid */
  55. /* This routine sets up the data for the double lines used for the */
  56. /*  background.  The codes for the double lines come from the      */
  57. /*  extended ASCII set.  They are actually output to the display   */
  58. /*  by the routine "linedisp()".                                   */
  59. void bkgndvid(void)
  60. {
  61. int index;
  62.    for (index = 0 ; index < 160 ; ++index)
  63.       outlist[index] = bkattr;
  64.       
  65.    for (index = 2 ; index <= 156 ; index += 2)
  66.       outlist[index] = HORIZ;
  67.    outlist[0]   = U_LEFT;
  68.    outlist[44]  = T_DOWN;
  69.    outlist[110] = T_DOWN;
  70.    outlist[158] = U_RIGHT;
  71.    linedisp(1);                   /* video line 1                  */
  72.  
  73.    for (index = 2 ; index <= 156 ; index += 2)
  74.       outlist[index] = BLANK;
  75.    outlist[0]   = VERT;
  76.    outlist[44]  = VERT;
  77.    outlist[110] = VERT;
  78.    outlist[158] = VERT;
  79.    for (index = 2 ; index <= 7 ; ++index)
  80.       linedisp(index);            /* video lines 2 to 7            */
  81.       
  82.    for (index = 2 ; index <= 156 ; index += 2)
  83.       outlist[index] = HORIZ;
  84.    outlist[0]   = T_RIGHT;
  85.    outlist[44]  = T_UP;
  86.    outlist[110] = T_UP;
  87.    outlist[158] = T_LEFT;
  88.    linedisp(8);                   /* video line 8                  */
  89.  
  90.    for (index = 2 ; index <= 156 ; index += 2)
  91.       outlist[index] = BLANK;
  92.    outlist[0]   = VERT;
  93.    outlist[158] = VERT;
  94.    for (index = 9 ; index <= 22 ; ++index)
  95.       linedisp(index);            /* video lines 9 to 22           */
  96.  
  97.    for (index = 2 ; index <= 156 ; index += 2)
  98.       outlist[index] = HORIZ;
  99.    outlist[0]   = T_RIGHT;
  100.    outlist[158] = T_LEFT;
  101.    linedisp(23);                  /* video line 23                 */
  102.  
  103.    for (index = 2 ; index <= 156 ; index += 2)
  104.       outlist[index] = BLANK;
  105.    outlist[0]   = VERT;
  106.    outlist[158] = VERT;
  107.    linedisp(24);                  /* video line 24                 */
  108.  
  109.    for (index = 2 ; index <= 156 ; index += 2)
  110.       outlist[index] = HORIZ;
  111.    outlist[0]   = L_LEFT;
  112.    outlist[158] = L_RIGHT;
  113.    linedisp(25);                  /* video line 25                 */
  114. }
  115.  
  116.  
  117.  
  118. /******************************************************** valusvid */
  119. /* This routine actually outputs the calculated data to the        */
  120. /*  monitor.  It outputs all values every time it is called, even  */
  121. /*  if only a few values are changed. It is therefore somewhat     */
  122. /*  inefficient.                                                   */
  123. void valusvid(struct vars *allvars)
  124. {
  125. long int temp;
  126.  
  127.    sprintf(strngout, "     A = %12.6f", allvars[0].value);
  128.    strngout[21] = 0;
  129.    strngdis(1, 1, valattr);
  130.    sprintf(strngout, "     B = %12.6f", allvars[1].value);
  131.    strngout[21] = 0;
  132.    strngdis(2, 1, valattr);
  133.    sprintf(strngout, "     C = %12.6f", allvars[2].value);
  134.    strngout[21] = 0;
  135.    strngdis(3, 1, valattr);
  136.    sprintf(strngout, "     D = %12.6f", allvars[3].value);
  137.    strngout[21] = 0;
  138.    strngdis(4, 1, valattr);
  139.    sprintf(strngout, "     E = %12.6f", allvars[4].value);
  140.    strngout[21] = 0;
  141.    strngdis(5,1,valattr);
  142.    sprintf(strngout, "     F = %12.6f", allvars[5].value);
  143.    strngout[21] = 0;
  144.    strngdis(6, 1, valattr);
  145.  
  146.    temp = (long int)allvars[6].value;
  147.    temp = temp & 077777777;
  148.    allvars[6].value = temp;
  149.    sprintf(strngout, "I = %8ld = %8lo = %6lx", temp, temp, temp);
  150.    strngdis(1, 23, valattr);
  151.    temp = (long int)allvars[7].value;
  152.    temp = temp & 077777777;
  153.    allvars[7].value = temp;
  154.    sprintf(strngout, "J = %8ld = %8lo = %6lx", temp, temp, temp);
  155.    strngdis(2, 23, valattr);
  156.    temp = (long int)allvars[8].value;
  157.    temp = temp & 077777777;
  158.    allvars[8].value = temp;
  159.    sprintf(strngout, "K = %8ld = %8lo = %6lx", temp, temp, temp);
  160.    strngdis(3, 23, valattr);
  161.    temp = (long int)allvars[9].value;
  162.    temp = temp & 077777777;
  163.    allvars[9].value = temp;
  164.    sprintf(strngout, "L = %8ld = %8lo = %6lx", temp, temp, temp);
  165.    strngdis(4, 23, valattr);
  166.    temp = (long int)allvars[10].value;
  167.    temp = temp & 077777777;
  168.    allvars[10].value = temp;
  169.    sprintf(strngout, "M = %8ld = %8lo = %6lx", temp, temp, temp);
  170.    strngdis(5, 23, valattr);
  171.    temp = (long int)allvars[11].value;
  172.    temp = temp & 077777777;
  173.    allvars[11].value = temp;
  174.    sprintf(strngout, "N = %8ld = %8lo = %6lx", temp, temp, temp);
  175.    strngdis(6,23,valattr);
  176.  
  177.    strcpy(strngout, "Function Keys --------");
  178.    strngdis(1, 56, helpattr);
  179.    strcpy(strngout, "F1-Help-M   F2-Help-S  ");
  180.    strngdis(2, 56, helpattr);
  181.    strcpy(strngout, "F3-Print    F4-Mark    ");
  182.    strngdis(3, 56, helpattr);
  183.    strcpy(strngout, "F5-Store    F6-Retrieve");
  184.    strngdis(4, 56, helpattr);
  185.    strcpy(strngout, "F7-         F8-        ");
  186.    strngdis(5, 56, helpattr);
  187.    strcpy(strngout, "F9-Edit     F10-Quit   ");
  188.    strngdis(6, 56, helpattr);
  189. }
  190.  
  191.  
  192.  
  193. /********************************************************** disnew */
  194. /* This routine displays the changed variable only.                */
  195. void disnew(int varinuse, struct vars *allvars)
  196. {
  197. long int temp;
  198. double xx;
  199.  
  200.    if (varinuse < 6) {            /* display A through F           */
  201.       xx = allvars[varinuse].value;
  202.       if (xx < 0.0) 
  203.          xx = -xx;
  204.       if ((xx > 9999999.0) || (xx < .001))
  205.          sprintf(strngout, "%12.5e", allvars[varinuse].value);
  206.       else
  207.          sprintf(strngout, "%12.6f", allvars[varinuse].value);
  208.       strngout[12] = 0;
  209.       strngdis(1 + varinuse, 10, valattr);
  210.    } else {                       /* display I through N           */
  211.       temp = (long int)allvars[varinuse].value;
  212.       temp = temp & 077777777;
  213.       allvars[varinuse].value = temp;
  214.       sprintf(strngout, "%8ld = %8lo = %6lx", temp, temp, temp);
  215.       strngdis(varinuse - 5, 27, valattr);
  216.    }
  217. }
  218.  
  219.  
  220.  
  221. /*********************************************************** helpm */
  222. /* This outputs the math helps to the monitor.                     */
  223. void helpm(void)
  224. {
  225. strtrans(" ", 0);
  226. strtrans("$                Help - Mathematics", 0);
  227. strtrans("$   All calculations are done in floating point, then", 0);
  228. strtrans("$  converted to fixed point for variables I to N.", 0);
  229. strtrans("$     Available    ABS()   SQRT()  EXP()   LOG()", 0);
  230. strtrans("$     Functions    SIN()   COS()   ATAN()  FACT()", 0);
  231. strtrans("$  Line length is limited to 62 characters.", 0);
  232. strtrans("$  Octal input, start with 0; in hex, start with 0x", 0);
  233. }
  234.  
  235.  
  236.  
  237. /*********************************************************** helps */
  238. /* This outputs the system helps to the monitor.                   */
  239. void helps(void)
  240. {
  241. strtrans(" ", 0);
  242. strtrans("$                   Help - System", 0);
  243. strtrans("$  Arrow - selected line   ;   Star - marked line", 0);
  244. strtrans("$  F3-Toggle print mode to print all input lines", 0);
  245. strtrans("$  F4-Toggle the mark indicator on selected line", 0);
  246. strtrans("$  F5-Store all marked lines to a file", 0);
  247. strtrans("$  F6-Retrieve a file and calculate while inputting", 0);
  248. strtrans("$  F9-Load selected line into input window", 0);
  249. strtrans("$  up/down-Move selector up/down 1 line", 0);
  250. strtrans("$  Pgup/Pgdn-Move selector up/down 8 lines", 0);
  251. }
  252.  
  253.  
  254.  
  255. /******************************************************** linedisp */
  256. /* This outputs a complete line with attributes already in place.  */
  257. void linedisp(int line)
  258. {
  259. struct SREGS segregs;
  260. unsigned int ds;
  261.  
  262.    segread(&segregs);
  263.    ds = segregs.ds;
  264.    movedata(ds, (int)outlist, vidstart, 160 * (line - 1), 160);
  265. }
  266.  
  267.  
  268.  
  269. /******************************************************** strngdis */
  270. /* The following functions call strndis() with the correct attri-  */
  271. /*  bute as desired by the calling program.  These are defined so  */
  272. /*  that the attributes do not have to be made global.             */
  273. void strngdis_val(int row, int col)
  274. {
  275.    strngdis(row, col, valattr);
  276. }
  277. void strngdis_help(int row, int col)
  278. {
  279.    strngdis(row, col, helpattr);
  280. }
  281. void strngdis_trns(int row, int col)
  282. {
  283.    strngdis(row, col, trnsattr);
  284. }
  285. /******************************************************** strngdis */
  286. /* This outputs a part of a line to the monitor, but first it adds */
  287. /*  the attribute bytes between each of the character bytes.       */
  288. void strngdis(int row, int col, int attr)
  289. {
  290. int i = 0;
  291. int j = 0;
  292. struct SREGS segregs;
  293. unsigned int ds;
  294.  
  295.    segread(&segregs);
  296.    ds = segregs.ds;
  297.  
  298.    while (strngout[i] && j <= 160) {
  299.       outlist[j] = strngout[i];
  300.       outlist[j + 1] = attr;
  301.       j += 2;
  302.       i++;
  303.    }
  304.    movedata(ds, (int)outlist, vidstart, 160 * row + 2 * col, j);
  305. }
  306.  
  307.  
  308.  
  309. /******************************************************** blnkline */
  310. /* This routine outputs blanks from here to column 79.             */
  311. void blnkline(int row, int col)
  312. {
  313. int i, j, number;
  314. struct SREGS segregs;
  315. unsigned int ds;
  316.  
  317.    segread(&segregs);
  318.    ds = segregs.ds;
  319.    number = 78 - col;
  320.    j = 0;
  321.    for (i = 0 ; i <= number ; ++i){
  322.       outlist[j] = ' ';
  323.       outlist[j + 1] = trnsattr;
  324.       j += 2;
  325.    }
  326.   movedata(ds, (int)outlist, vidstart, 
  327.                                     160 * row + 2 * col, 2 * number);
  328. }
  329.  
  330.  
  331.  
  332. /********************************************************* chardis */
  333. /* This function displays a single character with trns attr.       */
  334. void chardis_trns(int row, int col, int ch)
  335. {
  336.    chardis(row, col, trnsattr, ch);
  337. }
  338. /********************************************************* chardis */
  339. /* This function outputs one character anywhere on the screen.     */
  340. void chardis(int row, int col, int attr, int ch)
  341. {
  342. struct SREGS segregs;
  343. unsigned int ds;
  344.  
  345.    segread(&segregs);
  346.    ds = segregs.ds;
  347.    outlist[0] = ch;
  348.    outlist[1] = attr;
  349.    movedata(ds, (int)outlist, vidstart, 160*row + 2*col, 2);
  350. }
  351.  
  352.  
  353.  
  354. /********************************************************** errdis */
  355. /* This function displays the error message with the blinking      */
  356. /*  attribute.                                                     */
  357. void errdis(char str[])
  358. {
  359. int row = 21, col = 50;
  360. int i;
  361. struct SREGS segregs;
  362. unsigned int ds;
  363.  
  364.    segread(&segregs);
  365.    ds = segregs.ds;
  366.    for (i = 0 ; i <= 24 ; ++i) {
  367.       outlist[2*i] = str[i];
  368.       outlist[2*i+1] = errattr;
  369.    }
  370.    movedata(ds, (int)outlist, vidstart, 160*row + 2*col, 50);
  371. }
  372.  
  373.  
  374.  
  375. /********************************************************* clrscrn */
  376. /* This function clears the screen.                                */
  377. void clrscrn(void)
  378. {
  379. int row,col;
  380.  
  381.    for (row = 0 ; row < 25 ; ++row)
  382.       for (col = 0 ; col < 80 ; ++col)
  383.          chardis(row, col, 7, ' ');
  384. }
  385.  
  386.  
  387.  
  388. /********************************************************* poscurs */
  389. /* This function positions the cursor anywhere on the screen. It   */
  390. /*  calls the DOS function call 10, the video interrupt.           */
  391. void poscurs(int row, int col)
  392. {
  393. union REGS inregs;
  394. union REGS outregs;
  395.  
  396.    inregs.h.ah = 2;
  397.    inregs.h.dh = row;
  398.    inregs.h.dl = col;
  399.    inregs.h.bh = 0;
  400.    int86(0x10, &inregs, &outregs);
  401. }
  402.  
  403.  
  404.  
  405. /******************************************************** prtprblm */
  406. /* This function checks the printer to see if it is turned on and  */
  407. /*  on line. It returns a 1 if a problem, 0 if all is OK.          */
  408. int prtprblm(void)
  409. {
  410. union REGS inregs;
  411. union REGS outregs;
  412.  
  413.    inregs.h.ah = 2;
  414.    inregs.x.dx = 0;
  415.    int86(0x17, &inregs, &outregs);
  416.    if ((outregs.h.ah & 0X80) == 0X80)
  417.       return(0);
  418.    else
  419.       return(1);
  420. }
  421.